/**
 * 通知服务
 * 示例业务服务，展示如何在实际业务逻辑中使用 SSE 管理器
 */

const SSEManager = require('../infra/sseManager');
const { getLogger } = require('../logger');
const logger = getLogger('services.notificationService');

class NotificationService {
  constructor() {
    // 获取 SSE 管理器单例实例
    this.sseManager = SSEManager.getInstance();
    logger.info('通知服务已初始化');
  }

  /**
   * 发送系统公告给所有用户
   * @param {Object} announcement - 公告内容
   * @returns {number} 成功发送的连接数
   */
  sendSystemAnnouncement(announcement) {
    try {
      const message = {
        type: 'system_announcement',
        data: {
          ...announcement,
          id: `announcement_${Date.now()}`,
          timestamp: new Date().toISOString(),
          priority: announcement.priority || 'normal'
        }
      };

      const sentCount = this.sseManager.broadcast(message);
      logger.info(`系统公告已广播，成功发送到 ${sentCount} 个连接`);
      return sentCount;
    } catch (error) {
      logger.error('发送系统公告失败:', error);
      throw error;
    }
  }

  /**
   * 发送用户通知
   * @param {string} userId - 用户ID
   * @param {Object} notification - 通知内容
   * @returns {number} 成功发送的连接数
   */
  sendUserNotification(userId, notification) {
    try {
      const message = {
        type: 'user_notification',
        data: {
          ...notification,
          id: `notification_${Date.now()}_${userId}`,
          timestamp: new Date().toISOString(),
          read: false
        }
      };

      const sentCount = this.sseManager.sendToUser(userId, message);
      
      if (sentCount > 0) {
        logger.info(`用户通知已发送，用户: ${userId}，成功发送到 ${sentCount} 个连接`);
      } else {
        logger.warn(`用户 ${userId} 当前没有活跃的 SSE 连接，通知无法实时推送`);
        // 这里可以添加其他通知方式，如邮件、短信等
      }
      
      return sentCount;
    } catch (error) {
      logger.error(`发送用户通知失败，用户: ${userId}:`, error);
      throw error;
    }
  }

  /**
   * 发送聊天消息
   * @param {string} senderId - 发送者ID
   * @param {string} receiverId - 接收者ID
   * @param {string} content - 消息内容
   * @returns {number} 成功发送的连接数
   */
  sendChatMessage(senderId, receiverId, content) {
    try {
      const message = {
        type: 'chat_message',
        data: {
          id: `chat_${Date.now()}_${senderId}_${receiverId}`,
          senderId,
          content,
          timestamp: new Date().toISOString(),
          status: 'sent'
        }
      };

      const sentCount = this.sseManager.sendToUser(receiverId, message);
      
      if (sentCount > 0) {
        logger.info(`聊天消息已发送，从 ${senderId} 到 ${receiverId}`);
      } else {
        logger.info(`接收者 ${receiverId} 不在线，聊天消息已存储但未实时推送`);
      }
      
      return sentCount;
    } catch (error) {
      logger.error(`发送聊天消息失败:`, error);
      throw error;
    }
  }

  /**
   * 发送任务进度更新
   * @param {string} userId - 用户ID
   * @param {string} taskId - 任务ID
   * @param {number} progress - 进度百分比 (0-100)
   * @param {string} status - 任务状态
   */
  updateTaskProgress(userId, taskId, progress, status) {
    try {
      const message = {
        type: 'task_progress',
        data: {
          taskId,
          progress,
          status,
          timestamp: new Date().toISOString()
        }
      };

      this.sseManager.sendToUser(userId, message);
      logger.debug(`任务进度已更新，用户: ${userId}，任务: ${taskId}，进度: ${progress}%`);
    } catch (error) {
      logger.error(`更新任务进度失败:`, error);
      // 任务进度更新失败不应该影响主流程，所以这里只记录日志
    }
  }

  /**
   * 向特定角色的所有用户发送消息
   * @param {Array<string>} roleIds - 角色ID列表
   * @param {Object} message - 消息内容
   * @returns {number} 成功发送的连接数
   */
  sendToUsersByRole(roleIds, message) {
    try {
      // 这里应该有一个服务来获取特定角色的所有用户ID
      // 为了简化示例，这里直接模拟用户ID列表
      // const userIds = await roleService.getUserIdsByRoles(roleIds);
      
      // 示例：假设我们有一个用户ID列表
      const userIds = ['user1', 'user2', 'user3'];
      
      let totalSentCount = 0;
      
      // 向每个用户发送消息
      for (const userId of userIds) {
        const sentCount = this.sseManager.sendToUser(userId, {
          type: message.type || 'role_notification',
          data: {
            ...message.data,
            targetRoles: roleIds,
            timestamp: new Date().toISOString()
          }
        });
        totalSentCount += sentCount;
      }
      
      logger.info(`已向 ${roleIds.join(', ')} 角色的用户发送消息，成功发送到 ${totalSentCount} 个连接`);
      return totalSentCount;
    } catch (error) {
      logger.error(`向特定角色用户发送消息失败:`, error);
      throw error;
    }
  }

  /**
   * 获取当前通知服务状态
   * @returns {Object} 状态信息
   */
  getServiceStatus() {
    const stats = this.sseManager.getStats();
    return {
      activeConnections: stats.totalConnections,
      activeUsers: stats.totalUsers,
      status: 'operational'
    };
  }
}

// 导出服务实例
module.exports = new NotificationService();